/**
 * @Description: 工具类
 * @Author: wrysunny
 * @Date: 2024-11-18 14:01:05
 * @LastEditor: wrysunny
 * @LastEditTime: 2024-12-09 12:09:54
 */

/**
 * @description: 确认框
 * @param {String} content 内容
 * @return
 */
export const showModal = (content) => {
  return new Promise((resolve, reject) => {
    uni.showModal({
      title: "提示",
      content: content,
      confirmColor: "#d9915f",
      success: ({ confirm }) => {
        if (confirm) {
          resolve();
        } else {
          reject("取消操作");
        }
      },
    });
  });
};

/**
 * @description: 提示
 * @param {String} content 提示内容
 * @param {Boolean} mask 是否显示透明蒙层，防止触摸穿透
 * @return
 */
export const showToast = (content, mask = false) => {
  uni.showToast({
    title: content,
    icon: "none",
    duration: 2000,
    mask,
  });
};

/**
 * 提示方法
 * @param {String} title 提示文字
 * @param {String}  icon icon图片
 * @param {Number}  duration 提示时间
 */
export function toast(title, icon = "none", duration = 1500) {
  if (title) {
    uni.showToast({
      title,
      icon,
      duration,
    });
  }
}

/**
 * 页面跳转
 * @param {'navigateTo' | 'redirectTo' | 'reLaunch' | 'switchTab' | 'navigateBack' | number } url  转跳路径
 * @param {String} params 跳转时携带的参数
 * @param {String} type 转跳方式
 **/
export function useRouter(url, params = {}, type = "navigateTo") {
  try {
    if (Object.keys(params).length)
      url = `${url}?data=${encodeURIComponent(JSON.stringify(params))}`;
    if (type === "navigateBack") {
      uni[type]({
        delta: url,
      });
    } else {
      uni[type]({
        url,
      });
    }
  } catch (error) {
    console.error(error);
  }
}

/**
 * 预览图片
 * @param {Array} urls 图片链接
 */
export function previewImage(
  urls,
  itemList = ["发送给朋友", "保存图片", "收藏"]
) {
  uni.previewImage({
    urls,
    longPressActions: {
      itemList,
      fail: function (error) {
        console.error(error, "===previewImage");
      },
    },
  });
}

/**
 * 保存图片到本地
 * @param {String} filePath 图片临时路径
 **/
export function saveImage(filePath) {
  if (!filePath) return false;
  uni.saveImageToPhotosAlbum({
    filePath,
    success: () => {
      toast("图片保存成功", "success");
    },
    fail: (err) => {
      if (
        err.errMsg === "saveImageToPhotosAlbum:fail:auth denied" ||
        err.errMsg === "saveImageToPhotosAlbum:fail auth deny"
      ) {
        uni.showModal({
          title: "提示",
          content: "需要您授权保存相册",
          showCancel: false,
          success: () => {
            uni.openSetting({
              success(settingdata) {
                if (settingdata.authSetting["scope.writePhotosAlbum"]) {
                  uni.showModal({
                    title: "提示",
                    content: "获取权限成功,再次点击图片即可保存",
                    showCancel: false,
                  });
                } else {
                  uni.showModal({
                    title: "提示",
                    content: "获取权限失败，将无法保存到相册哦~",
                    showCancel: false,
                  });
                }
              },
              fail(failData) {
                console.log("failData", failData);
              },
            });
          },
        });
      }
    },
  });
}

/**
 * @description: 位置授权
 * @return {Promise}
 */
export function getAuthorize() {
  return new Promise((resolve, reject) => {
    uni.authorize({
      scope: "scope.userLocation",
      success: () => {
        // 1 用户允许授权
        // 2 用户之前已经同意授权，则不会出现弹窗，直接返回成功
        //  以上两种情况都会进入到success回调中
        resolve(); // 允许授权
      },
      fail: () => {
        // 1 用户拒绝授权
        // 2 用户之前拒绝了授权，此接口会直接进入失败回调
        //  以上两种情况都会进入到fail回调中
        reject(); // 拒绝授权
      },
    });
  });
}

/**
 * @description: 获取手机系统信息
 * @return {Promise}
 */
export function getSystemInfo() {
  return new Promise((resolve, reject) => {
    uni.getSystemInfo({
      success: (res) => {
        // 获取地理位置失败原因
        // 1.手机系统设置中地理位置未开启
        // 2.系统未给微信授权
        // 3.用户未给小程序授权地理位置信息
        if (!res.locationEnabled || !res.locationAuthorized) {
          uni.showToast({
            title: "请确保手机系统定位已开启",
            icon: "none",
            duration: 2000,
          });
          reject();
        } else {
          resolve();
        }
      },
    });
  });
}

/**
 * @description: 历史记录数组去重方法
 * @param {Array} array
 * @return {Array} 去重后的数组
 */
export function removeDuplicates(array) {
  return array.filter((value, index, self) => {
    return self.indexOf(value) === index;
  });
}

//base64转图片路径
export const writeFile = (base64Str) =>
  new Promise((resolve, reject) => {
    // 后台返回的base64格式数据的回车换行换为空字符''
    const base64Image = base64Str.split(",")[1].replace(/[\r\n]/g, "");
    // 文件管理器
    const fsm = wx.getFileSystemManager();
    // 文件名
    const FILE_BASE_NAME = "tmp_base64src";
    // 文件后缀
    const format = "png";
    // 获取当前时间戳用于区分小程序码，防止多次写进的小程序码图片都一样，建议通过不同的列表ID来区分不同的小程序码
    const timestamp = new Date().getTime();
    // base转二进制
    const buffer = wx.base64ToArrayBuffer(base64Image);
    // 文件名
    const filePath = `${wx.env.USER_DATA_PATH}/${timestamp}share.${format}`;
    // 写文件
    fsm.writeFile({
      filePath,
      data: buffer,
      encoding: "binary",
      success() {
        // 读取图片
        wx.getImageInfo({
          src: filePath,
          success(res) {
            const img = res.path;
            // 把需要画出来的图片的临时url暴露出去
            resolve(img);
            reject();
          },
          fail(e) {
            console.log("读取图片报错");
            console.log(e);
          },
          error(res) {
            console.log(res);
          },
        });
      },
      fail(e) {
        console.log(e);
      },
    });
  }).catch((e) => {
    console.log(e);
});

// 删除存储的垃圾数据
export const removeSave = () =>
  new Promise((resolve) => {
    // 文件管理器
    const fsm = wx.getFileSystemManager();
    // 获取文件列表
    fsm.readdir({
      dirPath: wx.env.USER_DATA_PATH, // 当时写入的文件夹
      success(res) {
        res.files.forEach((el) => {
          // 遍历文件列表里的数据
          // 删除存储的垃圾数据
          if (el !== "miniprogramLog") {
            // 过滤掉miniprogramLog
            fsm.unlink({
              filePath: `${wx.env.USER_DATA_PATH}/${el}`, // 文件夹也要加上，如果直接文件名会无法找到这个文件
              fail(e) {
                console.log("readdir文件删除失败：", e);
              },
            });
          }
        });
        resolve();
      },
    });
});

/**
 * @description: 获取小程序最新版本
 * @return
 */
export const getLatestVersion = () => {
  const updateManager = uni.getUpdateManager();

  updateManager.onCheckForUpdate(function (res) {
    // 请求完新版本信息的回调
    console.log(res.hasUpdate);
  });

  updateManager.onUpdateReady(function (res) {
    uni.showModal({
      title: "更新提示",
      content: "新版本已经准备好，是否重启应用？",
      success(res) {
        if (res.confirm) {
          // 新的版本已经下载好，调用 applyUpdate 应用新版本并重启
          updateManager.applyUpdate();
        }
      },
    });
  });

  updateManager.onUpdateFailed(function (res) {
    // 新的版本下载失败
  });
};

/**
 * @description: 获取url参数
 * @param {String} url
 * @return {Object} url参数
 */
export const getUrlValue = (url) => {
  console.log(url);
  // 通过 ? 分割获取后面的参数字符串
  let urlStr = url.split("?")[1];
  // 创建空对象存储参数
  let obj = {};
  // 再通过 & 将每一个参数单独分割出来
  let paramsArr = urlStr.split("&");
  for (let i = 0, len = paramsArr.length; i < len; i++) {
    // 再通过 = 将每一个参数分割为 key:value 的形式
    let arr = paramsArr[i].split("=");
    obj[arr[0]] = arr[1];
  }
  return obj;
};

/**
 * @description: 删除对象空字段
 * @param {Object} obj
 * @return {Object} 删除空字段后的对象
 */
export const removeEmptyValues = (obj) => {
  for (const key in obj) {
    if (obj[key] === null || obj[key] === undefined || obj[key] === "") {
      delete obj[key];
    } else if (
      typeof obj[key] === "object" &&
      Object.keys(obj[key]).length === 0
    ) {
      delete obj[key];
    }
  }
  return obj;
};

/**
 * @description: 复制文本
 * @param {String} text
 * @return
 */
export const copyText = (text) => {
  if (!text) {
    showToast("内容为空");
    return;
  }
  uni.setClipboardData({
    data: text,
    success: () => {
      showToast("复制成功");
    },
    fail: () => {
      showToast("复制失败");
    },
  });
};

/**
 *  睡眠函数
 *  @param numberMillis -- 要睡眠的毫秒数
 */
export const sleep = (numberMillis) => {
  var now = new Date();
  var exitTime = now.getTime() + numberMillis;
  while (true) {
    now = new Date();
    if (now.getTime() > exitTime) return;
  }
};

/**
 *  设置baseurl
 *  @param url -- 要设置的url
 */
export const setBaseUrl = (url) => {
  if (!url) {
    return "";
  }
  //如果是数组
  if (Array.isArray(url)) {
    return url.map((item) => {
      return setBaseUrl(item);
    });
  }
  //如果是对象
  if (typeof url === "object") {
    return Object.values(url).map((item) => {
      return setBaseUrl(item);
    });
  }
  //如果带有http 或 https 则直接返回
  if (url.indexOf("http") > -1) {
    return url;
  }
  return require("@/utils/http").BASE_URL + url;
};

export default {
  showModal,
  showToast,
  getLatestVersion,
  getUrlValue,
  removeEmptyValues,
  previewImage,
  copyText,
  sleep,
  setBaseUrl,
};
